/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package steg.steki.wav;

import java.beans.PropertyChangeListener;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.EOFException;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.LinkedHashMap;
import java.util.Random;
import java.util.zip.GZIPOutputStream;
import javax.swing.JComponent;
import javax.swing.SwingWorker;
import steg.steki.PlikSteg;
import steg.steki.StegException;
import steg.sekret.Sekret;
import steg.sekret.SekretInfo;
import steg.sekret.UnSekret;
import steg.utils.MojaLinkedHashMap;

/**
 *
 * @author Tryllion
 */
public class PlikWAV extends PlikSteg{


// =============================== ZIENNE PRYWATNE =============================
    //----- STAŁE WAV
    private static int KOMPRESJA_BRAK = 1; //w mft brak kompresji to 1
    private static String TAG_STRING_ERROR = "nieznany kod"; //w mft brak kompresji to 1

    
    //-------- meta dane, najważniejsze, także do rozpoznania pliku
        /*
         *Klasa ma przechowywać plik, jeśli jednak zostanie, zmieniony, skasowany
         * np. o wyłączeniu programu i po włączeniu po tygodniu, niech klasa
         * sama sprawdzi czy podszas uruchamiania steg() plik jest tym samym plikiem!
         * w miarę możliwości oczywiście
         */
    
    private int chAllFileSize;
    private long czasOstatniejModyfikacji;
    // fmt dane
    private int chFMTlenght;
    private short chCompressionCode;
    private short chNumberOfChannels;
    private int chSampleRate;
    private int chAverageBytesPerSecond;
    private short chBlockAlign;
    private short chSignificantBitsPerSample;
    private short chExtraFormatBytes;
    private static int CHMFT_NADMIARBITY_MAX_ILOSC = 0xFF;
    private byte[] chMFTnadmiaroweBity;

    private LinkedHashMap inneTagi = new LinkedHashMap() ; //tagi chunks które nie są ważne przy steganografi

    //task
    
    int dzielnikProgresu = 1; //liczba o jaka progress raza wolniej rosnie


// =============================== FUNKCJE KRYTYCZNE ===========================
    public void init(File file) throws StegException, IOException {

        plik = file;

        InputStream in = new FileInputStream(file);
        DataInputStream dataIn = new DataInputStream(in);

        //sprawdzic nagłówek
        readChunkHeader(dataIn);
        readChunkFMT(dataIn);

        //szukanie innych ciekawych tagów,
            //dane nie bedą wczytywane, do 4GB ! więc po co!!!
        readChunkInne(dataIn);


        //nie bylo błedów więc warto zanotować datę modyfikacji
        dataIn.close();
        czasOstatniejModyfikacji = file.lastModified();

    }


    /**
     * Funkcja steg z możliwością monitorowania procesu.
     * @return
     */
    @Override
    public Void doInBackground() {
        try {
            stegProcess();

            // -------------------------- INFO -----------------------------
            //wychodzi na to że wg Google Exceptiony wyżucae przez tą funckje doInB..
            // nidzie nie są łapane, zatem trzeba je przechować i o nich pamiętać, MASAKRA1!!
            //Exception przerywa oczywwiście działanie funkcji, a więc stąd idzie do done()
        } catch (StegException ex) {

            stegEx = ex;

        } catch (Exception ex) {

            stegEx = new StegException( ex, StegException.BLAD_UNSUPORTED, "");
            //this.firePropertyChange("state", StateValue.STARTED, StateValue.DONE);
        }
        return null;

    }

    @Override
    public void done() {

        /*W sumie to nic.*/

    }

    @Override
    public void stegProcess() throws StegException {

        //1 przygotowanie Sekret

            //plik z sekretem, może ulec zmianie po gzipie,
            //gzip owany plik wzucimy do sekretu, a potem go zastapimy starym
        File tempSekretFile = sekret.getFile();

        initSekret();


        // ================== WŁAŚCIWA STEGANOGRAFIA

try{
        //otwarcie pliku wzorca

        processNag = "Krok  4/9: rozpoczęcie steganografi";
        processMsg += " ..rozpoczęcie steganografi\n ..przygotowanie danych\n";
        addProgressInPercent(1);

        InputStream   in = new FileInputStream(plik);
        DataInputStream dataIn = new DataInputStream(in);

        // otwarcie pliku wzorca+info
        OutputStream out = new FileOutputStream( fileOut );
        DataOutputStream dataOut = new DataOutputStream(out);

        processNag = "Krok  5/9: otwarcie plików";
        processMsg += " ..otwarcie strumienia: "+plik.getAbsolutePath()+"\n";
        processMsg += " ..otwarcie strumienia: "+fileOut.getAbsolutePath()+"\n";
        addProgressInPercent(1);


        //start, init proces
        sekret.start();



            //1. przepisać tagi
        int dlTagow = 12 + chFMTlenght + 4; // 12 header, FMT, 4 "data"
        while (in.available() != 0 && dlTagow-- > 0) {
            dataOut.write(dataIn.readByte());
        }
        //-- czy wczytano wszystko
        if(dlTagow>0) {
            dataIn.close();
            dataOut.close();
            throw new StegException(new Exception("błędny format pliku"), StegException.BLAD_ZLY_FORMAT_PLIKU,"");

        }

        processNag = "Krok  6/9: przepisanie tagów";
        processMsg += " ..przepisano tagi ["+(12 + chFMTlenght + 4 - dlTagow)+"] \n";
        addProgressInPercent(1);



        //2. dlugosc pliku
        int dlData = dataIn.readInt();
        dataOut.writeInt(dlData);
        dlData = Integer.reverseBytes(dlData);


        //zmienne algorytmu
        byte bSteg,bMsg;
        int bns = sekret.getBitowNaSample();


        processNag = "Krok  7/9: steganowanie";
        processMsg += " ..steganowanie w ["+dlData+"]bitach \n";
        addProgressInPercent(1);



        double proc = (double)50/dlData; //50% ma to zajac

        if(dlData<=0)
            throw new StegException( new Exception("moje steg"), StegException.BLAD_ZLY_FORMAT_PLIKU, "Długość danych jest wartością ujemną.");

        //3 wczytaj dane
        while( --dlData>0 ) {

            bMsg = sekret.getNextMessageBit();

            // pobierz byte
            bSteg = dataIn.readByte();

            //czy już
            if(sekret.isEOF())
                break;

            // czyszczenie bitow i dodanie
            bSteg >>=bns;
            bSteg <<=bns;
            bSteg  |=bMsg;

            //wpisz biciki
            dataOut.write( bSteg );



            //
            addProgressInPercent(proc);
        }

        //cz y sie zmiescilo
        if(dlData<=0 && !sekret.isEOF())
            throw new StegException( new Exception("moje steg"), StegException.BLAD_ZLY_FORMAT_PLIKU, "Ukrywana wiadomość nie zmieściła się !");




        processNag = "Krok  8/9: dopełnianie pliku";
        processMsg += " ..dopełnianie ["+dlData+"]bitów \n";
        addProgressInPercent(1);


        //5 wczytaj wszystko pozostałe
        while( in.available() !=0 ) {
            dataOut.write(dataIn.read() );
            //progres
            addProgressInPercent(proc);
        }


        // jesli byl gzip to sekretme byl ten plik przed gzipowaniem, trzeba go przywrocic
        sekret.setFile(tempSekretFile);


        processNag = "Krok  9/9: zakańczanie";
        processMsg += " ..zamykanie strumieni [OK] \n";
        processMsg += " ..zczyszczenie bufora [OK] \n";
        processMsg += " ..GIZP cancel [OK] \n";
        addProgressInPercent(1);


    }catch(EOFException eofe) {
        //jak sie zdarzy
        throw new StegException(eofe, StegException.BLAD_ZLY_FORMAT_PLIKU, "Za mało miejsca aby schować wszystkie dane.");

    } catch (FileNotFoundException ex) {
        throw new StegException(ex, StegException.BLAD_MODYFIKACJI_PLIKU, "");
    } catch (IOException ex) {
        throw new StegException(ex, StegException.BLAD_MODYFIKACJI_PLIKU, "");
    }









/*

        }catch(Exception ex) {

            throw new StegException(ex, StegException.BLAD_UNSUPORTED, "" );

        }*/

    }

    public void unsteg(UnSekret unpaczka) throws StegException, IOException {

        try {

            //1. otworz odczyt/zapis
            OutputStream out = new FileOutputStream( unpaczka.getFile() ); //wczytujemy tam gdzie wskazuje unpaczka
            DataOutputStream undataOut = new DataOutputStream(out);

            InputStream in = new FileInputStream( this.getFile() ); //z tegoż pliku
            DataInputStream undataIn = new DataInputStream(in);

            //2 przeskocz nagowek
            int licznik = 12 + getFMTlenght() + 4; // 12 header, FMT, 4 "data";
            undataIn.skipBytes(licznik);

            //3. dlugosc pliku
            licznik = Integer.reverseBytes(undataIn.readInt() );


            // -- ALGORYTM --

            //zmienne algorytmu
            byte bSteg,bInfo=0;
            int bns = unpaczka.getSkBitowNaSample();

            //4. stworz maske
            byte maska = (byte) 0x7F;
            if(bns!=8)
                maska >>= 7-bns;
            else
                maska = (byte) 0xFF;


            int licznikBitow = 8-bns;



            int licznikTaga = 0;
            boolean fHaslo = true;
            int ileSczytano = 0;
            byte[] tagBits = new byte[13];
            SekretInfo sinfo = new SekretInfo();

            //5. wczytywanie, w przypadku EOT, wyżuci wyjątek
            while(--licznik>0 ) {

                // reset przesumiecia
                if(licznikBitow<0) {
    /***************************************************************************
     * TO DO:
     * Ehh this is bad okey, this is really bad ...
     *
     * rozwiazanie na tenczas na szybko bo mnie sie nie chce
     */
//byc moze tag
if(licznikTaga<13) {

    //zapis bo moze to tag
    tagBits[licznikTaga] = bInfo;



    if(++licznikTaga==13) {
        //wczytano cały tag, ale czy napewno ?
        UnSekret.parseSekretTag(sinfo, tagBits);

// blad, oczekiwano znacznika a nie ma lub znacznik jest wiec spadowa, bo moze byc hasko
        if(unpaczka.isZnacznik()!= sinfo.isTag() )
            throw new StegException(new Exception("steg rozny tag() set"), StegException.BLAD_ZLY_FORMAT_PLIKU,"W pliku przeszukiwanym wartość znacznik jest równa = " + sinfo.isTag() );

        if(unpaczka.isCzyHaslo()!= sinfo.isHaslo() )
            throw new StegException(new Exception("steg: haslo wymagane"), StegException.BLAD_ZLY_FORMAT_PLIKU,"Brak dostępu!" );

        //zapiszmy teraz to, badz nie
        if(!sinfo.isTag() ) undataOut.write( tagBits );

    }

}else{

    // byc moze haslo
    if( fHaslo && licznikTaga>=13 && licznikTaga<53 && sinfo.isHaslo() ) { // 45 to dlugosc haszu

        // ale potem sprawdzimy tu haslo

        System.out.println(licznikTaga +":-<>-:"+(char)bInfo);

        if( bInfo!=unpaczka.getSkHaslo()[licznikTaga-13] )
            throw new StegException(new Exception("steg: zle haslo:"+(char)tagBits[licznikTaga-13]+"!="+(char)unpaczka.getSkHaslo()[licznikTaga-13]), StegException.BLAD_ZLY_FORMAT_PLIKU,"Złe hasło!" );
        licznikTaga++;
    }else{

        //czy koniec wiadomosci wg taga ?
        if(sinfo.isTag() && ileSczytano>=sinfo.getLength() )
            break;

        // JUZ NE TAG WIEC ZAPIS DO pliku
        undataOut.writeByte( bInfo );
        ileSczytano++;

    }
    fHaslo = !fHaslo;
}
// ============= THE END TO DO  THE END TO DO  THE END TO DO  THE END TO DO ====

                    licznikBitow = 8-bns;
                    bInfo=0;
                }

                //pobranie bitow
                bSteg = undataIn.readByte();
                bSteg &= maska;

                //przesuniecie pobranych bitow
                bSteg <<= licznikBitow;

                //uzulelnienie informacji
                bInfo |=bSteg;

                licznikBitow-=bns;


                //dataOut.write( bSteg );



            }

            undataOut.close();
            undataIn.close();


        }catch(EOFException eofe) {
            //jak sie zdarzy
            throw new StegException(eofe, StegException.BLAD_ZLY_FORMAT_PLIKU, "");

        }
    }
// =============================== FUNKCJE DODATKOWE ===========================

    @Override
    public long getPojemnosc() {
        throw new UnsupportedOperationException("Not supported yet.");
    }
    
    public MojaLinkedHashMap getMetaDane() {

        MojaLinkedHashMap map = new MojaLinkedHashMap();

        map.put("Nazwa", plik.getName() );
        map.put("Rozmiar pliku", (chAllFileSize+8) );
        map.put("Kompresja", getTagStingCompression(chCompressionCode) );
        map.put("Ilość kanałów", chNumberOfChannels +" ("+ getTagStingChannels(chNumberOfChannels)+")" );
        map.put("Częstotliwość próbkowania", chSampleRate+"Hz");
        map.put("Szybkość transmisji bitów", chAverageBytesPerSecond);
        map.put("Block Align", chBlockAlign);
        map.put("Rozmiar próbki audio", chSignificantBitsPerSample);

        //nie zawsze są 24 bo tyle ma nie poszerzony chunk fmt
        if (chFMTlenght > 24) {
            map.put("chExtraFormatBytes", chExtraFormatBytes);
            map.put("chMFTnadmiaroweBity", chMFTnadmiaroweBity);
        }

        map.putAll(inneTagi);

        return map;
    }
// =============================== FUNKCJE dziwne ==============================
    public void reversFile( DataOutputStream dataOut ) throws StegException {

        try {


            InputStream in = new FileInputStream(plik);
            DataInputStream dataIn = new DataInputStream(in);
            //jest plik, teraz trzeba przepisać

                //1. przepisać tagi
            int dlTagow = 12 + chFMTlenght + 4; // 12 header, FMT, 4 "data"
            while (in.available() != 0 && dlTagow-- > 0) {
                dataOut.write(dataIn.read());
            }
            //-- czy wczytano wszystko
            if(dlTagow>0)
                throw new StegException(new Exception("steg err"), StegException.BLAD_ZLY_FORMAT_PLIKU,"");


                //2. dlugosc pliku
            int dlData = dataIn.readInt();
            dataOut.writeInt(dlData);
            dlData = Integer.reverseBytes(dlData);

            if (dlData < Integer.MAX_VALUE) {
                byte[] dataBits = new byte[dlData];
                int wczytano = 0;

                    //3. wczytanie danych
                while (in.available() != 0 && dlData-- > 0) {
                    dataBits[wczytano++] = dataIn.readByte();
                }
                //-- czy wczytano wszystko
                if(dlData++>0)
                    throw new StegException(new Exception("steg err"), StegException.BLAD_ZLY_FORMAT_PLIKU,"");


                //4. teraz ponowny zapis tych danych do pliku samplami wspak

                int licznik = -1;
                dlData = wczytano - chBlockAlign;

                if( wczytano%chBlockAlign!=0 )
                    throw new StegException(new Exception("steg err"), StegException.BLAD_ZLY_FORMAT_PLIKU,"");

                while ( wczytano > 0) {

                    //get 1 sample 80764
                    if(++licznik == chBlockAlign) {
                        dlData = wczytano-chBlockAlign;
                        licznik = 0;
                    }

                    if(dlData>=0)
                        dataOut.write( dataBits[dlData++] );
                    else{
                        System.out.println("------ BREAK, dlData<0:pozostało:"+wczytano);
                        throw new StegException(new Exception("steg err"), StegException.BLAD_ZLY_FORMAT_PLIKU, "Za mało miejsca aby schować wszystkie dane.");
                    }

                    wczytano--;
                }


                //5. doczytanie reszty tagów
                while (in.available() != 0) {
                    dataOut.write(dataIn.read());
                }

            } else {
                throw new StegException(new Exception("steg err, za malo pamieci"), StegException.BLAD_ZA_MALA_ILOSC_PAMIECI,"");
            }


            dataIn.close();
            dataOut.close();
            System.out.println("KONIEC REVERSOWANIA");

        } catch (Exception ex) {
            throw new StegException( ex, StegException.BLAD_UNSUPORTED,"");
        }
    }

    public void generateRandom(int width, int height) throws StegException {
        throw new UnsupportedOperationException("Not supported yet.");
    }


    
// =============================================================================
// =============================== FUNKCJE PRYWATNE ============================

//===================== FUNKCJE PRYWATNE ===================================
    /**
     * Sczytuje nagłówek który jest dla przydzielony PNG.
     *
     * @param in
     * @throws java.io.IOException
     */
    private void readChunkHeader(DataInputStream in) throws StegException, IOException {
        int nagowek = in.readInt();
        if (nagowek != 0x52494646L)
            throw new StegException(new Exception("steg err"),StegException.BLAD_ZLY_FORMAT_PLIKU,"Nagłówek RIFF nie został znaleziony!");
        //zgraj nagłówek fileOut size
        chAllFileSize = Integer.reverseBytes( in.readInt() );
        nagowek = in.readInt();
        if (nagowek != 0x57415645L)
            throw new StegException(new Exception("steg err"),StegException.BLAD_ZLY_FORMAT_PLIKU,"Nagłówek WAVE nie został znaleziony!");

    }

    private void readChunkFMT(DataInputStream in) throws StegException, IOException {
        int nagowek = in.readInt();
        if (nagowek != 0x666D7420L)
            throw new StegException(new Exception("steg err"),StegException.BLAD_ZLY_FORMAT_PLIKU,"Nagłówek FMT nie został znaleziony!");

        //zgraj nagłówek fileOut size: 16 + extra format bytes + 8 (tj. ID i chFMTlenght bo sie nie zaliczaja)
        chFMTlenght = Integer.reverseBytes( in.readInt() ) + 8;

        //zgraj reszt parameterów
        chCompressionCode = Short.reverseBytes( in.readShort() );
        chNumberOfChannels = Short.reverseBytes( in.readShort() );
        chSampleRate = Integer.reverseBytes( in.readInt() );
        chAverageBytesPerSecond = Integer.reverseBytes( in.readInt() );
        chBlockAlign = Short.reverseBytes( in.readShort() );
        chSignificantBitsPerSample = Short.reverseBytes( in.readShort() );


        //System.out.println("chFMTlenght:"+chFMTlenght);

        //dodatkowe bity, bo mtf moze zmiescic jakis krap dodatkowy
        if (chFMTlenght-24 > CHMFT_NADMIARBITY_MAX_ILOSC)
            throw new StegException( new Exception("moj steg"), StegException.BLAD_ZLY_FORMAT_PLIKU,"Dodatkowych bitów w chunk FMT jest ponad MAX=["+CHMFT_NADMIARBITY_MAX_ILOSC+"]");
        if (chFMTlenght != 24) {

            // to chyba jest lenght chMFTnadmiaroweBity
            chExtraFormatBytes = Short.reverseBytes( in.readShort() );

            chMFTnadmiaroweBity = new byte[chFMTlenght-22];
            in.readFully(chMFTnadmiaroweBity);
        }


    }

    private void readChunkInne(DataInputStream in) throws IOException {

        int cztery,dl;
        byte[] bity;
        while (in.available() != 0) {
            cztery = in.readInt();

            switch(cztery) {
                //- tekstowe
                
                //windows tag
                case 0x4c495354:
                    dl = Integer.reverseBytes(in.readInt() );
                    bity = new byte[dl];
                    in.readFully(bity);
                    inneTagi.put("Windows tag", new String(bity) );
                break;
                //list
                case 0x6C696E74:
                    dl = Integer.reverseBytes(in.readInt() );
                    bity = new byte[dl];
                    in.readFully(bity);
                    inneTagi.put("chunk fact", new String(bity) );
                break;
                //labl
                case 0x6C61626C:
                    dl = Integer.reverseBytes(in.readInt() );
                    bity = new byte[dl];
                    in.readFully(bity);
                    inneTagi.put("chunk labl", new String(bity) );
                break;
                //note
                case 0x6E6F7465:
                    dl = Integer.reverseBytes(in.readInt() );
                    bity = new byte[dl];
                    in.readFully(bity);
                    inneTagi.put("chunk note", new String(bity) );
                break;


                //fact
                case 0x66616374:
                    dl = Integer.reverseBytes(in.readInt() );
                    in.skip(dl);
                    inneTagi.put("chunk fact", "bitów:("+dl+")");
                break;
                //wavl
                case 0x736C6E74:
                    dl = Integer.reverseBytes(in.readInt() );
                    in.skip(dl);
                    inneTagi.put("chunk wavl", "bitów:("+dl+")");
                break;
                /*//slnt zawiera sie w wavl
                case 0x736C6E74:
                    dl = Integer.reverseBytes(in.readInt() );
                    in.skip(dl);
                    inneTagi.put("chunk slnt", "bitów:("+dl+")");
                break;*/
                //cue
                case 0x63756520:
                    dl = Integer.reverseBytes(in.readInt() );
                    in.skip(dl);
                    inneTagi.put("chunk cue ", "bitów:("+dl+")");
                break;
                /*//plst
                case 0x736C6E74:
                    dl = Integer.reverseBytes(in.readInt() );
                    in.skip(dl);
                    inneTagi.put("chunk plst", "bitów:("+dl+")");
                break;*/
               //ltxt
                case 0x6C747874:
                    dl = Integer.reverseBytes(in.readInt() );
                    in.skip(dl);
                    inneTagi.put("chunk ltxt", "bitów:("+dl+")");
                break;
               //smpl
                case 0x736D706C:
                    dl = Integer.reverseBytes(in.readInt() );
                    in.skip(dl);
                    inneTagi.put("chunk smpl", "bitów:("+dl+")");
                break;
               /*//inst taki sam jak plst
                case 0x6C747874:
                    dl = Integer.reverseBytes(in.readInt() );
                    in.skip(dl);
                    inneTagi.put("chunk inst", "bitów:("+dl+")");
                break;*/



            }
            

        }

    }

    
    //-- kod kompresji, nie ma sensu robić to na static, bo to się NIE MA PRAWA ZMMIENIĆ
    //-- przeci to międzynarodowy standard
    private String getTagStingCompression(int kod) {

        switch(kod) {
            case 0:
                return "Unknown";
            case 1:
                return "PCM/uncompressed";
            case 2:
                return "Microsoft ADPCM";
            case 6:
                return "ITU G.711 a-law";
            case 7:
                return "ITU G.711 Âµ-law";
            case 17:
                return "IMA ADPCM";
            case 20:
                return "ITU G.723 ADPCM (Yamaha)";
            case 49:
                return "GSM 6.10";
            case 64:
                return "ITU G.721 ADPCM";
            case 80:
                return "MPEG";
            case 0xFFFF:
                return "Experimental";
            default:
                return TAG_STRING_ERROR;
        }
    }
    private String getTagStingChannels(int kod) {

        switch(kod) {
            case 1:
                return "mono";
            case 2:
                return "stereo";
            default:
                return TAG_STRING_ERROR;
        }
    }



    // -- get set
    public int getAllFileSize() {
        return chAllFileSize;
    }

    public void setAllFileSize(int chAllFileSize) {
        this.chAllFileSize = chAllFileSize;throw new UnsupportedOperationException("Not supported yet.");
    }

    public int getAverageBytesPerSecond() {
        return chAverageBytesPerSecond;
    }

    public void setAverageBytesPerSecond(int chAverageBytesPerSecond) {
        this.chAverageBytesPerSecond = chAverageBytesPerSecond;throw new UnsupportedOperationException("Not supported yet.");
    }

    public short getBlockAlign() {
        return chBlockAlign;
    }

    public void setBlockAlign(short chBlockAlign) {
        this.chBlockAlign = chBlockAlign;throw new UnsupportedOperationException("Not supported yet.");
    }

    public short getCompressionCode() {
        return chCompressionCode;
    }

    public void setCompressionCode(short chCompressionCode) {
        this.chCompressionCode = chCompressionCode;throw new UnsupportedOperationException("Not supported yet.");
    }

    public short getExtraFormatBytes() {
        return chExtraFormatBytes;
    }

    public void setExtraFormatBytes(short chExtraFormatBytes) {
        this.chExtraFormatBytes = chExtraFormatBytes;throw new UnsupportedOperationException("Not supported yet.");
    }

    public int getFMTlenght() {
        return chFMTlenght;
    }

    public void setFMTlenght(int chFMTlenght) {
        this.chFMTlenght = chFMTlenght;throw new UnsupportedOperationException("Not supported yet.");
    }

    public byte[] getMFTnadmiaroweBity() {
        return chMFTnadmiaroweBity;
    }

    public void setMFTnadmiaroweBity(byte[] chMFTnadmiaroweBity) {
        this.chMFTnadmiaroweBity = chMFTnadmiaroweBity;throw new UnsupportedOperationException("Not supported yet.");
    }

    public short getNumberOfChannels() {
        return chNumberOfChannels;
    }

    public void setNumberOfChannels(short chNumberOfChannels) {
        this.chNumberOfChannels = chNumberOfChannels;throw new UnsupportedOperationException("Not supported yet.");
    }

    public int getSampleRate() {
        return chSampleRate;
    }

    public void setSampleRate(int chSampleRate) {
        this.chSampleRate = chSampleRate;throw new UnsupportedOperationException("Not supported yet.");
    }

    public short getSignificantBitsPerSample() {
        return chSignificantBitsPerSample;
    }

    public void setSignificantBitsPerSample(short chSignificantBitsPerSample) {
        this.chSignificantBitsPerSample = chSignificantBitsPerSample;throw new UnsupportedOperationException("Not supported yet.");
    }

    public long getCzasOstatniejModyfikacji() {
        return czasOstatniejModyfikacji;
    }

    public void setCzasOstatniejModyfikacji(long czasOstatniejModyfikacji) {
        this.czasOstatniejModyfikacji = czasOstatniejModyfikacji;throw new UnsupportedOperationException("Not supported yet.");
    }

    public LinkedHashMap getInneTagi() {
        return inneTagi;
    }

    public void setInneTagi(LinkedHashMap inneTagi) {
        this.inneTagi = inneTagi;throw new UnsupportedOperationException("Not supported yet.");
    }









// ------------------------------------- KLASY ----------------------------------



    //else

    @Deprecated
    public void unsteg(File fileIn, UnSekret paczka) throws StegException, IOException {
        throw new UnsupportedOperationException("Not supported yet.");
    }


}
